package com.hca.training.zk.javabasic.IOTest;

import org.junit.Test;

import java.io.*;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
import java.util.Properties;
import java.util.Set;

/**\
 * 字节流，字符流
 * 字节缓冲流，字符缓冲流
 * 单个字节，字节数组
 * ===============================前面必须掌握
 * 打印流:（掌握）
 *       （1）字节打印流，字符打印流
 *       （2）特点：A:只操作目的地，不操作数据源
 *                 B：可以操作任意类型的数据
 *
 * 内存操作流 :（理解）
 *        (1)有时候我们操作完毕后，未必需要产生一个文件，就可以使用内存操作流。
 *       （2）三种 A:ByteArrayInputStream,ByteArrayOutputStream
 *                B:CharArraryReader,CharArrayWriter
 *                C:StringReader,StringWriter
 *
 * ，标准输入输出流（理解），随机访问流（理解），合并流（理解），序列化流（理解） 基本数据类型（理解） 的流 NIO（理解）
 * 和IO流想结合使用的集合类
 *         Properties :可以保存在流中加载，属性列表中每个键及对应值都是一个字符串。是Hashtable的子类，说明是一个Map集合。
 */
public class IOTest {
    @Test
    public  void  tests()  {

//        try {
            //        File file=new File("D:\\ideaproject");
            //        getImage(file);
//            fileOutputstream("张凯:");
//            copyFile();
//            showzhongwen();
//            copyImage();
//            testOutputstreamWriter();
//            testCopyFile2();
            //  testReader();
//            testprintWriter();
            testProperties();
//        } catch (IOException e) {
//            e.printStackTrace();
//        }
//
    }
    /**
     * 文字节流    件写入数据(一次一个字节)
     *
     * @param message
     * @throws IOException
     */
    private static void fileOutputstream(String message) throws IOException {
        FileOutputStream fileOutputStream = new FileOutputStream("d:\\test\\zhang\\zhang.txt");
        for (int x = 0; x < 10; x++) {
            fileOutputStream.write((message + x).getBytes());
            fileOutputStream.write("\r\n".getBytes());
        }
    }
    /**
     * 字节流    拷贝数据字节流(一次一个字节)
     */
    private static void copyFile() throws IOException {
        FileInputStream a = new FileInputStream("d:\\test\\zhang\\zhang.txt");
        FileOutputStream b = new FileOutputStream("d:\\test\\zhang\\zhangyan.txt");
        int by = 0;
        while ((by = a.read()) != -1) {
            b.write(by);
        }
        a.close();
        b.close();
    }
    /**
     * 字节流    查看中文在计算机中的存储  两个字节一个中文
     */
    private static void showzhongwen() {
        String s = "我爱你中国";
        byte[] bys = s.getBytes();
        System.out.println(Arrays.toString(bys));

    }
    /**
     * 字节流    字节流复制图片(一次一个字节)
     */
    private static void copyImage() throws IOException {
        FileInputStream a = new FileInputStream("d:\\test\\zhang\\a.jpg");
        FileOutputStream b = new FileOutputStream("d:\\test\\zhang\\b.jpg");
        int by = 0;
        while ((by = a.read()) != -1) {
            b.write(by);
        }
        a.close();
        b.close();
    }
    /**
     * 字节流    通过字节(数组)拷贝图片
     *
     * @throws IOException
     */
    private static void copyImages() throws IOException {
        FileInputStream a = new FileInputStream("d:\\test\\zhang\\a.jpg");
        FileOutputStream b = new FileOutputStream("d:\\test\\zhang\\c.jpg");
        byte[] bytes = new byte[1024];
        int bys = 0;
        while ((bys = a.read(bytes)) != -1) {
            b.write(bytes, 0, bys);
        }
        a.close();
        b.close();
    }
//    =======================================================================   字符流   ==================================
    /**
     * 字符流：  eg：OutputStreamWriter InputStreamReader   转换需要编码的（字符流）
     */
    private static void testOutputstreamWriter() throws IOException {
        //写字符流 几种方法
        char[] chars = {'a', 'b', 'c'};
        OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream("d:\\test\\zhang\\zhang.txt"), "utf-8");
        outputStreamWriter.write("中国");  //都在缓存区里面，有时候数据量大需要flush一下
        outputStreamWriter.write(chars);
        outputStreamWriter.write(97);
        outputStreamWriter.write("你好你是最棒的", 2, 3);
        outputStreamWriter.flush();   //刷新缓冲区，一般不用几百G可以用
        outputStreamWriter.close();  //先刷新一下缓冲区，再关闭
        //读字符流 两种方式
        InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream("d:\\test\\zhang\\zhang.txt"), "utf-8");
        int ch = 0;
        while ((ch = inputStreamReader.read()) != -1) {
            System.out.println((char) ch);
        }
        char[] chars1 = new char[1024];
        while ((ch = inputStreamReader.read(chars1)) != -1) {
            System.out.println(new String(chars1, 0, ch));
        }
        inputStreamReader.close();
    }
    /**
     * 字符流    复制文件
     */
    private static void testCopyFile() throws IOException {
        //方式1
        InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream("d:\\test\\zhang\\zhang.txt"), "utf-8");
        OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream("d:\\test\\zhang\\yan.txt"), "utf-8");
        int ch = 0;     //一次一字符
        while ((ch = inputStreamReader.read()) != -1) {
            outputStreamWriter.write(ch);
//            outputStreamWriter.flush();上G
        }
        inputStreamReader.close();
        outputStreamWriter.close();
        //方式2 FileReader是InputStreamReader的简单封装
        char[] chars={'q','s','s'};
        FileReader fileReader = new FileReader("d:\\test\\zhang\\zhang.txt");
        System.out.println(fileReader.getEncoding());
        FileWriter fileWriter = new FileWriter("d:\\test\\zhang\\kaikai.txt");
        while ((ch=fileReader.read(chars))!=-1)//一次一字符数组
        {
            fileWriter.write(ch);
        }
        fileReader.close();
        fileWriter.close();
    }
    /**
     * 字符缓冲流    复制文件
     */
    private static void testCopyFile2() throws IOException {
        int ch = 0;     //一次一字符
        char[] chars={'q','s','s'};
        BufferedReader br=new BufferedReader(new FileReader("d:\\test\\zhang\\zhang.txt"));
        BufferedWriter  bw=new BufferedWriter(new FileWriter("d:\\test\\zhang\\kaikai.txt"));
        //方式2
        while ((ch=br.read(chars))!=-1)
        {
            bw.write(ch);
            bw.flush();
        }
        br.close();
        bw.close();
    }
    /**
     *  字符缓冲流的特殊方法 一次读一行数据，不按照一个字节或者字节数组读
     */
    private static  void testWrite() throws IOException {
        BufferedWriter bw=new BufferedWriter(new FileWriter("d:\\test\\zhang\\zhang.txt"));
        for (int i=0;i<10;i++)
        {
            bw.write("hello"+i);
            bw.newLine();//换行
            bw.flush();
        }
        bw.close();
    }
    private static  void testReader() throws IOException {
        BufferedReader bw=new BufferedReader(new FileReader("d:\\test\\zhang\\zhang.txt"));
        String line=null;
        while ((line=bw.readLine())!=null)
        {
            System.out.println(line);
        }
        bw.close();
    }
    /**
     * 打印流的改进版
     */
    private static  void testprintWriter() throws IOException {
        BufferedReader bw=new BufferedReader(new FileReader("d:\\test\\zhang\\zhang.txt"));
        PrintWriter pw=new PrintWriter(new FileWriter("d:\\test\\zhang\\zhangkai.txt"),true);
        String line=null;
        while ((line=bw.readLine())!=null)
        {
           pw.println(line);
        }
        bw.close();
        pw.close();
    }
    /**
     * 基本数据 输出流  输入流
     */
    private static  void testDataOutput_Write() throws IOException {
        DataOutputStream dw=new DataOutputStream(new FileOutputStream("d:\\test\\zhang\\zhang.txt"));
        //写入数据
         dw.writeByte(10);
         dw.writeShort(100);
         dw.writeInt(1000);
         dw.writeLong(10000);
         //释放资源
        dw.close();
    }
    private static  void testDataInput_Read() throws IOException {
        DataInputStream dw=new DataInputStream(new FileInputStream("d:\\test\\zhang\\zhang.txt"));
        //读出数据
      byte b=dw.readByte();
      short s=dw.readShort();
      int i =dw.readInt();
      long l=dw.readLong();
      //释放资源
        dw.close();
        System.out.println(b+"   "+s+"    "+i+"   "+l);

    }
    /**
     * 包含Io流的集合类
     */
    private  static  void testProperties()
    {
        //作为Map集合的使用。
        //下面这种用法是错误的，一定要看API,如果没有<>，就说明不是一个泛型类。
        //Properties<String,String> prop=new Properties<String,String>();
        Properties prop=new Properties();
        //添加元素
        prop.put("01","hellow");
        prop.put("02","你好");
        //便利集合
        Set<Object> set=prop.keySet();
        for (Object key:set)
        {
          Object value=prop.get(key);
            System.out.println(value);
        }
    }
}



//    String s="2018-12-5";
//        SimpleDateFormat dateFormat=new SimpleDateFormat("yyyy-mm-dd");
//        Date da= null;
//        try {
//            da = dateFormat.parse(s);
//        } catch (ParseException e) {
//            e.printStackTrace();
//            System.out.println(e.toString());
//        }
//        System.out.println(da);